[WIP] Feature post release hook

src/config.rs

@@ -29,6 +29,7 @@ pub struct Config {
     pub pre_release_replacements: Option<Vec<Replace>>,
     pub post_release_replacements: Option<Vec<Replace>>,
     pub pre_release_hook: Option<Command>,
+    pub post_release_hook: Option<Command>,
     pub tag_message: Option<String>,
     pub tag_prefix: Option<String>,
     pub tag_name: Option<String>,
@@ -77,6 +78,7 @@ impl Config {
             pre_release_replacements: Some(empty.pre_release_replacements().to_vec()),
             post_release_replacements: Some(empty.post_release_replacements().to_vec()),
             pre_release_hook: empty.pre_release_hook().cloned(),
+            post_release_hook: empty.post_release_hook().cloned(),
             tag_message: Some(empty.tag_message().to_owned()),
             tag_prefix: None, // Skipping, its location dependent
             tag_name: Some(empty.tag_name().to_owned()),
@@ -149,6 +151,9 @@ impl Config {
         if let Some(pre_release_hook) = source.pre_release_hook.as_ref() {
             self.pre_release_hook = Some(pre_release_hook.to_owned());
         }
+        if let Some(post_release_hook) = source.post_release_hook.as_ref() {
+            self.post_release_hook = Some(post_release_hook.to_owned());
+        }
         if let Some(tag_message) = source.tag_message.as_deref() {
             self.tag_message = Some(tag_message.to_owned());
         }
@@ -271,6 +276,10 @@ impl Config {
         self.pre_release_hook.as_ref()
     }
 
+    pub fn post_release_hook(&self) -> Option<&Command> {
+        self.post_release_hook.as_ref()
+    }
+
     pub fn tag_message(&self) -> &str {
         self.tag_message
             .as_deref()

src/release.rs

@@ -662,7 +662,28 @@ fn release_packages<'m>(
         }
     }
 
-    // STEP 7: git push
+    // STEP 7: post-release hook
+    for pkg in pkgs {
+        if let (Some(post_rel_hook), Some(_)) =
+            (pkg.config.post_release_hook(), pkg.version.as_ref())
+        {
+            let cwd = pkg.package_root;
+            let post_rel_hook = post_rel_hook.args();
+            log::debug!("Calling post-release hook: {:?}", post_rel_hook);
+            let envs = maplit::btreemap! {
+                OsStr::new("RELEASE_TAG") => OsStr::new(pkg.tag.as_ref().expect("post-release hook with no tag")),
+                OsStr::new("DRY_RUN") => OsStr::new(if dry_run { "true" } else { "false" }),
+            };
+            // we use dry_run environmental variable to run the script
+            // so here we set dry_run=false and always execute the command.
+            if !cmd::call_with_env(post_rel_hook, envs, cwd, false)? {
+                log::error!("Post release hook failed. Aborting. CHANGES NOT ROLLED BACK.",);
+                return Ok(107);
+            }
+        }
+    }
+
+    // STEP 8: git push
     if ws_config.push() {
         let mut shared_refs = HashSet::new();
         for pkg in pkgs {

tests/post-release-hook/crate/.gitignore

@@ -0,0 +1 @@
+target

tests/post-release-hook/crate/Cargo.toml

@@ -0,0 +1,5 @@
+[package]
+name = "post-release-hook-crate"
+version = "1.2.3"
+edition = "2021"
+publish = false

tests/post-release-hook/crate/release.toml

@@ -0,0 +1,2 @@
+push = false
+post-release-hook = ["cargo", "run"]

tests/post-release-hook/crate/src/main.rs

@@ -0,0 +1,9 @@
+use std::env;
+
+fn main() {
+    eprintln!("START_ENV_VARS");
+    for (key, value) in env::vars_os() {
+        eprintln!("{}={}", key.to_string_lossy(), value.to_string_lossy());
+    }
+    eprintln!("END_ENV_VARS");
+}

tests/post-release-hook/main.rs

@@ -0,0 +1,132 @@
+use assert_fs::prelude::*;
+use assert_fs::TempDir;
+use maplit::hashset;
+use std::collections::HashSet;
+use std::env;
+use std::fmt::Debug;
+use std::path::Path;
+use std::process::{Command, Stdio};
+use std::str::Lines;
+
+#[test]
+fn krate() {
+    let root = Path::new("tests/post-release-hook/crate")
+        .canonicalize()
+        .unwrap();
+    let expected = hashset! {
+        EnvVar::new("RELEASE_TAG", "v1.2.3"),
+        EnvVar::new("DRY_RUN", "true"),
+    };
+    let output = run_cargo_release(root.as_path());
+    let mut output = output.lines();
+    let actual = read_env_var_dump(&mut output).expect("missing env var dump");
+    assert!(
+        actual.is_superset(&expected),
+        "not all expected env vars are present and matching\n{expected:#?}"
+    );
+}
+
+#[test]
+fn workspace() {
+    let ws_root = Path::new("tests/post-release-hook/workspace")
+        .canonicalize()
+        .unwrap();
+    let expected = vec![
+        hashset! {
+            EnvVar::new("RELEASE_TAG", "post-release-hook-ws-a-v42.42.42"),
+            EnvVar::new("DRY_RUN", "true"),
+        },
+        hashset! {
+            EnvVar::new("RELEASE_TAG", "post-release-hook-ws-b-v420.420.420"),
+            EnvVar::new("DRY_RUN", "true"),
+        },
+    ];
+    let output = run_cargo_release(ws_root.as_path());
+    let mut output = output.lines();
+    let mut actual = Vec::new();
+    while let Some(vars) = read_env_var_dump(&mut output) {
+        actual.push(vars);
+    }
+    for expected in expected {
+        assert!(actual.iter().any(|actual| actual.is_superset(&expected)));
+    }
+}
+
+fn run_cargo_release(dir: &Path) -> String {
+    let temp = TempDir::new().unwrap();
+    temp.copy_from(dir, &["**"]).unwrap();
+
+    git(temp.path(), &["init"]);
+    git(temp.path(), &["add", "."]);
+    git(
+        temp.path(),
+        &["commit", "--message", "this is a commit message"],
+    );
+
+    let mut cargo = env::var_os("CARGO").map_or_else(|| Command::new("cargo"), Command::new);
+    let output = cargo
+        .stderr(Stdio::piped())
+        .args(["run", "--manifest-path"])
+        .arg(Path::new(PROJECT_ROOT).join("Cargo.toml"))
+        .args(["--", "release", "-vv"])
+        .current_dir(&temp)
+        .spawn()
+        .unwrap()
+        .wait_with_output()
+        .unwrap();
+
+    temp.close().unwrap();
+
+    if !output.status.success() {
+        panic!("cargo release exited with {}", output.status);
+    }
+    let output = String::from_utf8(output.stderr).unwrap();
+    eprintln!("{output}");
+    output
+}
+
+fn git(dir: &Path, args: &[&str]) {
+    assert!(Command::new("git")
+        .args(args)
+        .current_dir(dir)
+        .spawn()
+        .unwrap()
+        .wait()
+        .unwrap()
+        .success());
+}
+
+fn read_env_var_dump(lines: &mut Lines) -> Option<HashSet<EnvVar>> {
+    let mut variables = HashSet::new();
+    loop {
+        if lines.next()?.trim() == "START_ENV_VARS" {
+            break;
+        }
+    }
+    loop {
+        let line = lines.next().expect("missing end of env var dump").trim();
+        if line == "END_ENV_VARS" {
+            return Some(variables);
+        }
+
+        let (key, value) = line.split_once('=').unwrap();
+        variables.insert(EnvVar::new(key, value));
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+struct EnvVar {
+    key: String,
+    value: String,
+}
+
+impl EnvVar {
+    fn new(key: &str, value: &str) -> Self {
+        Self {
+            key: key.to_owned(),
+            value: value.to_owned(),
+        }
+    }
+}
+
+const PROJECT_ROOT: &str = concat!(env!("CARGO_MANIFEST_DIR"));

tests/post-release-hook/workspace/.gitignore

@@ -0,0 +1 @@
+../crate/.gitignore

tests/post-release-hook/workspace/Cargo.toml

@@ -0,0 +1,2 @@
+[workspace]
+members = ["a", "b"]

tests/post-release-hook/workspace/a/Cargo.toml

@@ -0,0 +1,5 @@
+[package]
+name = "post-release-hook-ws-a"
+version = "42.42.42"
+edition = "2021"
+publish = false

tests/post-release-hook/workspace/a/src

@@ -0,0 +1 @@
+../../crate/src/

tests/post-release-hook/workspace/b/Cargo.toml

@@ -0,0 +1,5 @@
+[package]
+name = "post-release-hook-ws-b"
+version = "420.420.420"
+edition = "2021"
+publish = false

tests/post-release-hook/workspace/b/src

@@ -0,0 +1 @@
+../../crate/src/

tests/post-release-hook/workspace/release.toml

@@ -0,0 +1 @@
+../crate/release.toml