Changelog generator (#533)

Generates a changelog based on the pr descriptions. Also fixed a few issues with the markdown generation.

Author: IceSentry

generate-release/.gitignore

@@ -6,3 +6,4 @@ out.md
 migration-guide.md
 release-notes.md
 release-notes-website.md
+changelog.md

generate-release/src/changelog.rs

@@ -0,0 +1,62 @@
+use crate::{
+    github_client::{GithubClient, GithubIssuesResponse},
+    helpers::{get_merged_prs, get_pr_area},
+    markdown::write_markdown_section,
+};
+use std::{collections::BTreeMap, fmt::Write, path::PathBuf};
+
+pub fn generate_changelog(
+    from: &str,
+    to: &str,
+    path: PathBuf,
+    client: &mut GithubClient,
+) -> anyhow::Result<()> {
+    let mut out = String::new();
+
+    let mut areas = BTreeMap::<String, Vec<(String, GithubIssuesResponse)>>::new();
+
+    let merged_prs = get_merged_prs(client, from, to, None)?;
+    for (pr, _, title) in &merged_prs {
+        let area = get_pr_area(pr);
+        areas
+            .entry(area)
+            .or_insert(Vec::new())
+            .push((title.clone(), pr.clone()));
+    }
+
+    writeln!(out, "# Changelog")?;
+
+    let mut count = 0;
+    for (area, prs) in areas {
+        writeln!(out, "## {area}")?;
+
+        let mut prs = prs;
+        prs.sort_by_key(|k| k.1.closed_at);
+
+        for (title, pr) in prs {
+            println!("# {title}");
+
+            if let Some(body) = pr.body.as_ref() {
+                let heading = format!(
+                    "\n### [{}](https://github.com/bevyengine/bevy/pull/{})",
+                    title, pr.number
+                );
+                writeln!(&mut out, "{heading}")?;
+
+                if write_markdown_section(body, "changelog", &mut out, false)? {
+                    count += 1;
+                } else {
+                    // Changelog not found so remove heading
+                    // We need to do this because we don't know if there's a changelog when writing the heading
+                    out = out.replace(&heading, "");
+                }
+            }
+        }
+    }
+
+    println!("\nFound {count} PRs with a changelog");
+
+    std::fs::write(path, out)?;
+
+    Ok(())
+}

generate-release/src/github_client.rs

@@ -119,17 +119,6 @@ impl GithubClient {
             .set("Authorization", &format!("bearer {}", self.token))
     }
 
-    pub fn get_branch_sha(&self, branch_name: &str) -> anyhow::Result<String> {
-        let request = self.get("branches");
-        let reponse: Vec<GithubBranchesResponse> = request.call()?.into_json()?;
-        for branch in &reponse {
-            if branch.name == branch_name {
-                return Ok(branch.commit.sha.clone());
-            }
-        }
-        bail!("commit sha not found for main branch")
-    }
-
     /// Gets the list of all commits between two git ref
     pub fn compare_commits(
         &self,

generate-release/src/main.rs

@@ -1,11 +1,14 @@
+use changelog::generate_changelog;
 use clap::{Parser as ClapParser, Subcommand};
 use migration_guide::generate_migration_guide;
 use release_notes::generate_release_note;
 use release_notes_website::generate_release_notes_website;
 use std::path::PathBuf;
 
+mod changelog;
 mod github_client;
 mod helpers;
+mod markdown;
 mod migration_guide;
 mod release_notes;
 mod release_notes_website;
@@ -40,9 +43,13 @@ struct Args {
 #[derive(Subcommand)]
 enum Commands {
     MigrationGuide {
-        /// Date of the release of the previous version. Format: YYYY-MM-DD
-        #[arg(short, long)]
-        date: String,
+        /// The name of the branch / tag to start from
+        #[arg(long)]
+        from: String,
+
+        /// The name of the branch / tag to end on
+        #[arg(long)]
+        to: String,
 
         /// Title of the frontmatter
         #[arg(short, long)]
@@ -82,6 +89,19 @@ enum Commands {
         #[arg(short, long)]
         path: Option<std::path::PathBuf>,
     },
+    Changelog {
+        /// The name of the branch / tag to start from
+        #[arg(short, long)]
+        from: String,
+
+        /// The name of the branch / tag to end on
+        #[arg(short, long)]
+        to: String,
+
+        /// Path used to output the generated file. Defaults to ./changelog.md
+        #[arg(short, long)]
+        path: Option<std::path::PathBuf>,
+    },
 }
 
 fn main() -> anyhow::Result<()> {
@@ -100,14 +120,16 @@ fn main() -> anyhow::Result<()> {
 
     match args.command {
         Commands::MigrationGuide {
-            date,
+            from,
+            to,
             title,
             weight,
             path,
         } => generate_migration_guide(
             &title,
             weight,
-            &date,
+            &from,
+            &to,
             path.unwrap_or_else(|| PathBuf::from("./migration-guide.md")),
             &mut client,
         )?,
@@ -123,6 +145,12 @@ fn main() -> anyhow::Result<()> {
             path.unwrap_or_else(|| PathBuf::from("./release-notes-website.md")),
             &mut client,
         )?,
+        Commands::Changelog { from, to, path } => generate_changelog(
+            &from,
+            &to,
+            path.unwrap_or_else(|| PathBuf::from("./changelog.md")),
+            &mut client,
+        )?,
     };
 
     Ok(())

generate-release/src/markdown.rs

@@ -0,0 +1,133 @@
+use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag};
+use std::fmt::Write;
+
+/// Writes the markdown section of the givent section header to the output.
+/// The header name needs to be in lower case.
+pub fn write_markdown_section(
+    body: &str,
+    section_header: &str,
+    output: &mut String,
+    write_todo: bool,
+) -> anyhow::Result<bool> {
+    // Parse the body of the PR
+    let mut options = Options::empty();
+    options.insert(Options::ENABLE_TABLES);
+    options.insert(Options::ENABLE_SMART_PUNCTUATION);
+    let mut markdown = Parser::new_ext(body, options);
+    let mut section_found = false;
+
+    while let Some(event) = markdown.next() {
+        if section_found {
+            break;
+        }
+
+        let Event::Start(Tag::Heading(heading_level, _, _)) = event else {
+            continue;
+        };
+
+        // Find the section header
+        // Sometimes people will write code in the header
+        if let Some(Event::Text(heading_text) | Event::Code(heading_text)) = markdown.next() {
+            if !heading_text.to_lowercase().contains(section_header) {
+                continue;
+            }
+        }
+
+        section_found = true;
+        markdown.next(); // skip heading end event
+
+        // Write the section's content
+        let mut list_item_level = 0;
+        for event in markdown.by_ref() {
+            match event {
+                Event::Start(Tag::Heading(level, _, _)) => {
+                    if level <= heading_level {
+                        // go until next heading
+                        break;
+                    }
+                }
+                Event::Start(Tag::List(_)) => list_item_level += 1,
+                Event::End(Tag::List(_)) => list_item_level -= 1,
+                Event::End(Tag::Heading(level, _, _)) => {
+                    if level == heading_level {
+                        println!("!!! end of heading !!!");
+                    }
+                }
+                Event::Start(Tag::Link(_, _, _)) => {
+                    write!(output, "[")?;
+                    continue;
+                }
+                Event::End(Tag::Link(_, ref link, _)) => {
+                    write!(output, "]({link})")?;
+                    continue;
+                }
+                _ => {}
+            }
+            write_markdown_event(&event, output, list_item_level - 1)?;
+        }
+    }
+
+    if !section_found {
+        // Someone didn't write a migration guide 😢
+        if write_todo {
+            writeln!(output, "\n<!-- TODO -->")?;
+            println!("\x1b[93m{section_header} not found!\x1b[0m");
+        }
+        Ok(false)
+    } else {
+        Ok(true)
+    }
+}
+
+/// Write the markdown Event based on the Tag
+/// This handles some edge cases like some code blocks not having a specified lang
+/// This also makes sure the result has a more consistent formatting
+fn write_markdown_event(
+    event: &Event,
+    output: &mut String,
+    list_item_level: i32,
+) -> anyhow::Result<()> {
+    match event {
+        Event::Start(Tag::CodeBlock(CodeBlockKind::Fenced(lang))) => writeln!(
+            output,
+            "\n```{}",
+            if lang.is_empty() {
+                "rust".to_string()
+            } else {
+                lang.to_string()
+            }
+        )?,
+        Event::End(Tag::CodeBlock(CodeBlockKind::Fenced(_))) => writeln!(output, "```")?,
+        Event::Start(Tag::CodeBlock(CodeBlockKind::Indented)) => writeln!(output, "\n```",)?,
+        Event::End(Tag::CodeBlock(CodeBlockKind::Indented)) => writeln!(output, "```")?,
+        Event::Start(Tag::Emphasis) | Event::End(Tag::Emphasis) => write!(output, "_")?,
+        Event::Start(Tag::Heading(_, _, _)) => {
+            // A few guides used headings for emphasis,
+            // since we use headings for the actual header of the guide, we need to use a different way to convey emphasis
+            write!(output, "\n__")?
+        }
+        Event::End(Tag::Heading(_, _, _)) => writeln!(output, "__")?,
+        // FIXME List currently always assume they are unordered
+        Event::Start(Tag::List(_)) => writeln!(output)?,
+        Event::End(Tag::List(_)) => {}
+        Event::Start(Tag::Item) => {
+            // Add indentation
+            for _ in 0..list_item_level {
+                write!(output, "  ")?;
+            }
+            write!(output, "- ")?
+        }
+        Event::End(Tag::Item) => writeln!(output)?,
+        Event::Start(Tag::Paragraph) => writeln!(output)?,
+        Event::End(Tag::Paragraph) => writeln!(output)?,
+        Event::Text(text) => write!(output, "{text}")?,
+        Event::Code(text) => write!(output, "`{text}`")?,
+        Event::SoftBreak => writeln!(output)?,
+        Event::Start(Tag::BlockQuote) => write!(output, "\n> ")?,
+        Event::End(Tag::BlockQuote) => writeln!(output)?,
+        Event::Html(html) => write!(output, "{html}")?,
+        Event::Rule => writeln!(output, "---")?,
+        _ => println!("\x1b[93mUnknown event: {event:?}\x1b[0m"),
+    };
+    Ok(())
+}