Add matrix step summary

src/commands/generate_buildpack_matrix/command.rs

@@ -62,9 +62,13 @@ pub(crate) fn execute(args: &GenerateBuildpackMatrixArgs) -> Result<()> {
         .collect::<Result<Vec<_>>>()?;
 
     let buildpacks_json =
-        serde_json::to_string(&buildpacks_info).map_err(Error::SerializingJson)?;
+        serde_json::to_string_pretty(&buildpacks_info).map_err(Error::SerializingJson)?;
 
-    actions::set_output("buildpacks", buildpacks_json).map_err(Error::SetActionOutput)?;
+    actions::set_output("buildpacks", &buildpacks_json).map_err(Error::WriteActionData)?;
+    actions::set_summary(format!(
+        "## Buildpack Matrix:\n```json\n{buildpacks_json}\n```"
+    ))
+    .map_err(Error::WriteActionData)?;
 
     let versions = buildpacks
         .iter()
@@ -80,7 +84,7 @@ pub(crate) fn execute(args: &GenerateBuildpackMatrixArgs) -> Result<()> {
         .next()
         .ok_or(Error::FixedVersion(versions.clone()))?;
 
-    actions::set_output("version", version).map_err(Error::SetActionOutput)?;
+    actions::set_output("version", version).map_err(Error::WriteActionData)?;
 
     let rust_triples = buildpacks
         .iter()
@@ -92,7 +96,7 @@ pub(crate) fn execute(args: &GenerateBuildpackMatrixArgs) -> Result<()> {
         "rust_triples",
         serde_json::to_string(&rust_triples).map_err(Error::SerializingJson)?,
     )
-    .map_err(Error::SetActionOutput)?;
+    .map_err(Error::WriteActionData)?;
 
     Ok(())
 }
@@ -101,12 +105,12 @@ pub(crate) fn execute(args: &GenerateBuildpackMatrixArgs) -> Result<()> {
 pub(crate) struct BuildpackInfo {
     buildpack_id: String,
     buildpack_version: String,
+    buildpack_type: BuildpackType,
     buildpack_dir: PathBuf,
     targets: Vec<TargetInfo>,
     image_repository: String,
     stable_tag: String,
     temporary_tag: String,
-    buildpack_type: BuildpackType,
 }
 
 #[derive(Serialize)]

src/commands/generate_buildpack_matrix/errors.rs

@@ -1,7 +1,7 @@
 use libcnb_data::buildpack::Target;
 
 use crate::buildpacks::{FindReleasableBuildpacksError, ReadBuildpackDescriptorError};
-use crate::github::actions::SetActionOutputError;
+use crate::github::actions::WriteActionDataError;
 use std::collections::HashSet;
 use std::path::PathBuf;
 
@@ -20,7 +20,7 @@ pub(crate) enum Error {
     #[error("Expected all buildpacks to have the same version but multiple versions were found:\n{}", list_versions(.0))]
     FixedVersion(HashSet<String>),
     #[error(transparent)]
-    SetActionOutput(SetActionOutputError),
+    WriteActionData(WriteActionDataError),
     #[error("Unknown target configuration. Couldn't determine a rust triple for {0:?}.")]
     UnknownRustTarget(Target),
     #[error("Couldn't determine buildpack type. Found evidence for two or more buildpack types (bash, composite, libcnb.rs) in {0}.")]

src/commands/generate_changelog/errors.rs

@@ -1,6 +1,6 @@
 use crate::buildpacks::{FindReleasableBuildpacksError, ReadBuildpackDescriptorError};
 use crate::changelog::ChangelogError;
-use crate::github::actions::SetActionOutputError;
+use crate::github::actions::WriteActionDataError;
 use std::path::PathBuf;
 
 #[derive(Debug, thiserror::Error)]
@@ -16,5 +16,5 @@ pub(crate) enum Error {
     #[error("Could not parse changelog\nPath: {}\nError: {1}", .0.display())]
     ParsingChangelog(PathBuf, #[source] ChangelogError),
     #[error(transparent)]
-    SetActionOutput(SetActionOutputError),
+    SetActionOutput(WriteActionDataError),
 }

src/commands/prepare_release/errors.rs

@@ -1,6 +1,6 @@
 use crate::buildpacks::FindReleasableBuildpacksError;
 use crate::changelog::ChangelogError;
-use crate::github::actions::SetActionOutputError;
+use crate::github::actions::WriteActionDataError;
 use libcnb_data::buildpack::BuildpackVersion;
 use std::collections::HashMap;
 use std::io;
@@ -13,7 +13,7 @@ pub(crate) enum Error {
     #[error(transparent)]
     FindReleasableBuildpacks(FindReleasableBuildpacksError),
     #[error(transparent)]
-    SetActionOutput(SetActionOutputError),
+    SetActionOutput(WriteActionDataError),
     #[error("Invalid URL `{0}` for argument --repository-url\nError: {1}")]
     InvalidRepositoryUrl(String, #[source] uriparse::URIError),
     #[error("Invalid Version `{0}` for argument --declarations-starting-version\nError: {1}")]

src/github/actions.rs

@@ -2,40 +2,46 @@ use std::fs::OpenOptions;
 use std::io::{stdout, Write};
 use std::{io, iter};
 
+pub(crate) fn set_summary<M: Into<String>>(markdown: M) -> Result<(), WriteActionDataError> {
+    let markdown = markdown.into();
+    write_data("GITHUB_STEP_SUMMARY", format!("{markdown}\n").as_bytes())
+}
+
 pub(crate) fn set_output<N: Into<String>, V: Into<String>>(
     name: N,
     value: V,
-) -> Result<(), SetActionOutputError> {
+) -> Result<(), WriteActionDataError> {
     let name = name.into();
     let value = value.into();
-
     let line = if value.contains('\n') {
         let delimiter: String = iter::repeat_with(fastrand::alphanumeric).take(20).collect();
         format!("{name}<<{delimiter}\n{value}\n{delimiter}")
     } else {
         format!("{name}={value}")
     };
     let line = format!("{line}\n");
+    write_data("GITHUB_OUTPUT", line.as_bytes())
+}
 
-    let mut file: Box<dyn Write> = match std::env::var("GITHUB_OUTPUT") {
+fn write_data(env_name: &str, data: &[u8]) -> Result<(), WriteActionDataError> {
+    let mut file: Box<dyn Write> = match std::env::var(env_name) {
         Ok(github_output) => {
             let append_file = OpenOptions::new()
                 .append(true)
                 .open(github_output)
-                .map_err(SetActionOutputError::Opening)?;
+                .map_err(WriteActionDataError::Opening)?;
             Box::new(append_file)
         }
         Err(_) => Box::new(stdout()),
     };
 
-    file.write_all(line.as_bytes())
-        .map_err(SetActionOutputError::Writing)
+    file.write_all(data).map_err(WriteActionDataError::Writing)
 }
 
 #[derive(Debug, thiserror::Error)]
-pub(crate) enum SetActionOutputError {
-    #[error("Could not open action output\nError: {0}")]
+pub(crate) enum WriteActionDataError {
+    #[error("Could not open action data file\nError: {0}")]
     Opening(#[source] io::Error),
-    #[error("Could not write action output\nError: {0}")]
+    #[error("Could not write action data file\nError: {0}")]
     Writing(#[source] io::Error),
 }