Add an optional suffix file to template

Signed-off-by: Marcel Müller <neikos@neikos.email>

4 files changed, 138 insertions, 8 deletions

diff --git a/.changelogs/template.md b/.changelogs/template.md
index 3cf83f8..fe05a00 100644
--- a/.changelogs/template.md
+++ b/.changelogs/template.md
@@ -16,3 +16,6 @@
 {{~ /each ~}}
 {{~ /each ~}}
 {{/if}}
+{{#if this.suffix}}
+{{this.suffix}}
+{{/if}}
diff --git a/assets/default_template.handlebars.md b/assets/default_template.handlebars.md
index fc99288..2b3002c 100644
--- a/assets/default_template.handlebars.md
+++ b/assets/default_template.handlebars.md
@@ -16,3 +16,6 @@
 {{~ /each ~}}
 {{~ /each ~}}
 {{/if}}
+{{#if this.suffix}}
+{{this.suffix}}
+{{/if}}
diff --git a/src/command/release_command.rs b/src/command/release_command.rs
index 436e25d..f9b5f80 100644
--- a/src/command/release_command.rs
+++ b/src/command/release_command.rs
@@ -31,7 +31,32 @@ impl crate::command::Command for ReleaseCommand {
             .join(config.template_path());
         let template_source = std::fs::read_to_string(template_path)?;
         let template = crate::template::new_handlebars(&template_source)?;
-        let template_data = compute_template_data(load_release_files(workdir, config, self.all))?;
+
+        let suffix_path = workdir.join(config.fragment_dir()).join("suffix.md");
+        let suffix = match std::fs::read_to_string(&suffix_path) {
+            Ok(suffix) => Some(suffix),
+            Err(err) => {
+                match err.kind() {
+                    std::io::ErrorKind::NotFound => {
+                        // We don't want to spam the user for something they don't use
+                        log::trace!(
+                            "Did not find {}, not appending suffix",
+                            suffix_path.display()
+                        )
+                    }
+                    _ => {
+                        log::error!(
+                            "Could not read suffix file at {}: {err}",
+                            suffix_path.display()
+                        );
+                    }
+                }
+                None
+            }
+        };
+
+        let template_data =
+            generate_template_data(load_release_files(workdir, config, self.all), suffix)?;
 
         let changelog_contents =
             template.render(crate::consts::INTERNAL_TEMPLATE_NAME, &template_data)?;
@@ -117,6 +142,13 @@ fn load_release_files(
         })
 }
 
+/// The data sent to the handlebars template
+#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, getset::Getters)]
+pub struct TemplateData {
+    versions: Vec<VersionData>,
+    suffix: Option<String>,
+}
+
 /// Helper type for storing version associated with Fragments
 ///
 /// only used for handlebars templating
@@ -128,9 +160,10 @@ pub struct VersionData {
     entries: Vec<Fragment>,
 }
 
-fn compute_template_data(
+fn generate_template_data(
     release_files: impl Iterator<Item = Result<(Option<semver::Version>, Fragment), Error>>,
-) -> Result<HashMap<String, Vec<VersionData>>, Error> {
+    suffix: Option<String>,
+) -> Result<TemplateData, Error> {
     let versions = {
         use itertools::Itertools;
         let mut hm = HashMap::new();
@@ -150,9 +183,10 @@ fn compute_template_data(
             .sorted_by(|va, vb| va.version.cmp(&vb.version))
     };
 
-    let mut hm: HashMap<String, Vec<VersionData>> = HashMap::new();
-    hm.insert("versions".to_string(), versions.collect());
-    Ok(hm)
+    Ok(TemplateData {
+        versions: versions.collect(),
+        suffix,
+    })
 }
 
 #[cfg(test)]
@@ -164,7 +198,7 @@ mod tests {
 
     #[test]
     fn test_template_data_is_sorted() {
-        let result = compute_template_data(
+        let result = generate_template_data(
             [
                 Ok((
                     Some(semver::Version::new(0, 2, 0)),
@@ -190,12 +224,13 @@ mod tests {
                 )),
             ]
             .into_iter(),
+            None,
         );
 
         assert!(result.is_ok());
         let result = result.unwrap();
 
-        let versions = result.get("versions").unwrap();
+        let versions = result.versions;
         assert_eq!(versions[0].version, "0.1.0");
         assert_eq!(versions[1].version, "0.2.0");
     }
diff --git a/tests/release_command.rs b/tests/release_command.rs
index 24cad11..b8bf018 100644
--- a/tests/release_command.rs
+++ b/tests/release_command.rs
@@ -127,3 +127,92 @@ fn release_command_works_for_alpha_release() {
     assert!(changelog.contains("0.1.0-alpha.1"));
     assert!(changelog.contains("test text"));
 }
+
+#[test]
+fn release_command_works_with_suffix() {
+    let temp_dir = tempfile::Builder::new()
+        .prefix("cargo-changelog")
+        .tempdir()
+        .unwrap();
+    self::common::init_git(temp_dir.path());
+    self::common::init_cargo(temp_dir.path(), "release_command_works_with_suffix");
+    self::common::init_cargo_changelog(temp_dir.path());
+
+    self::common::cargo_changelog_new(temp_dir.path())
+        .args([
+            "--format=toml",
+            "--set",
+            "issue=123",
+            "--set",
+            "subject='Test subject'",
+            "--set",
+            "type=Misc",
+        ])
+        .assert()
+        .success();
+
+    let unreleased_dir = temp_dir.path().join(".changelogs").join("unreleased");
+
+    let new_fragment_file_path = std::fs::read_dir(unreleased_dir)
+        .unwrap()
+        .into_iter()
+        .find(|rde| match rde {
+            Ok(de) => !de.path().ends_with(".gitkeep"),
+            Err(_) => true,
+        })
+        .unwrap()
+        .unwrap();
+
+    let mut new_fragment_file = std::fs::OpenOptions::new()
+        .write(true)
+        .append(true)
+        .create(false)
+        .open(new_fragment_file_path.path())
+        .unwrap();
+
+    writeln!(new_fragment_file).unwrap();
+    writeln!(new_fragment_file, "test text").unwrap();
+    new_fragment_file.sync_all().unwrap();
+    drop(new_fragment_file);
+
+    {
+        let suffix_path = temp_dir.path().join(".changelogs").join("suffix.md");
+
+        let mut suffix_file = std::fs::OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(suffix_path)
+            .unwrap();
+
+        writeln!(suffix_file, "this is the suffix part").unwrap();
+        suffix_file.sync_all().unwrap();
+    }
+
+    Command::cargo_bin("cargo-changelog")
+        .unwrap()
+        .args(["generate", "custom", "0.1.0-alpha.1"])
+        .current_dir(&temp_dir)
+        .assert()
+        .success();
+
+    Command::cargo_bin("cargo-changelog")
+        .unwrap()
+        .args(["release"])
+        .current_dir(&temp_dir)
+        .assert()
+        .success();
+
+    let changelog_file_path = temp_dir.path().join("CHANGELOG.md");
+    if !changelog_file_path.exists() {
+        panic!("Changelog does not exist");
+    }
+
+    if !changelog_file_path.is_file() {
+        panic!("Changelog is not a file");
+    }
+
+    let changelog = std::fs::read_to_string(changelog_file_path).unwrap();
+    assert!(changelog.contains("0.1.0-alpha.1"));
+    assert!(changelog.contains("test text"));
+    assert!(changelog.contains("this is the suffix part"));
+}