Introduce a range-diff viewer for GitHub force-push

Author: Urgau

Cargo.lock

@@ -48,6 +48,8 @@ clap = { version = "4", features = ["derive"] }
 hmac = "0.12.1"
 subtle = "2.6.1"
 sha2 = "0.10.9"
+imara-diff = "0.2.0"
+pulldown-cmark-escape = "0.11.0"
 
 [dependencies.serde]
 version = "1"

Cargo.toml

@@ -0,0 +1,316 @@
+use std::collections::HashSet;
+use std::fmt::{self, Write};
+use std::sync::Arc;
+
+use anyhow::Context as _;
+use axum::{
+    extract::{Path, State},
+    http::HeaderValue,
+    response::IntoResponse,
+};
+use hyper::header::CACHE_CONTROL;
+use hyper::{
+    HeaderMap, StatusCode,
+    header::{CONTENT_SECURITY_POLICY, CONTENT_TYPE},
+};
+use imara_diff::{
+    Algorithm, Diff, InternedInput, Interner, Token, UnifiedDiffConfig, UnifiedDiffPrinter,
+};
+use pulldown_cmark_escape::FmtWriter;
+
+use crate::{github, handlers::Context, utils::AppError};
+
+/// Compute and renders an emulated `git range-diff` between two pushes (old and new).
+///
+/// `basehead` is `OLDHEAD..NEWHEAD`, both `OLDHEAD` and `NEWHEAD` must be SHAs or branch names.
+pub async fn gh_range_diff(
+    Path((owner, repo, basehead)): Path<(String, String, String)>,
+    State(ctx): State<Arc<Context>>,
+) -> axum::response::Result<impl IntoResponse, AppError> {
+    let Some((oldhead, newhead)) = basehead.split_once("..") else {
+        return Ok((
+            StatusCode::BAD_REQUEST,
+            HeaderMap::new(),
+            format!("`{basehead}` is not in the form `base..head`"),
+        ));
+    };
+
+    // Configure unified diff
+    let config = UnifiedDiffConfig::default();
+
+    let repos = ctx
+        .team
+        .repos()
+        .await
+        .context("unable to retrieve team repos")?;
+
+    // Verify that the request org is part of the Rust project
+    let Some(repos) = repos.repos.get(&owner) else {
+        return Ok((
+            StatusCode::BAD_REQUEST,
+            HeaderMap::new(),
+            format!("organization `{owner}` is not part of the Rust Project team repos"),
+        ));
+    };
+
+    // Verify that the request repo is part of the Rust project
+    if !repos.iter().any(|r| r.name == repo) {
+        return Ok((
+            StatusCode::BAD_REQUEST,
+            HeaderMap::new(),
+            format!("repository `{owner}` is not part of the Rust Project team repos"),
+        ));
+    }
+
+    let issue_repo = github::IssueRepository {
+        organization: owner.to_string(),
+        repository: repo.to_string(),
+    };
+
+    // Determine the oldbase and get the comparison for the old diff
+    let old = async {
+        // We need to determine the oldbase (ie. the parent sha of all the commits of old).
+        // Fortunatly GitHub compare API returns the the merge base commit when comparing
+        // two different sha.
+        //
+        // Unformtunatly for us we don't know in which tree the parent is (could be master, beta, stable, ...)
+        // so for now we assume that the parent is in the default branch (that we hardcore for now to "master").
+        //
+        // We therefore compare those the master and oldhead to get a guess of the oldbase.
+        //
+        // As an optimization we compare them in reverse to speed up things. The resulting
+        // patches won't be correct, but we only care about the merge base commit which
+        // is always correct no matter the order.
+        let oldbase = ctx
+            .github
+            .compare(&issue_repo, "master", oldhead)
+            .await
+            .context("failed to retrive the comparison between newhead and oldhead")?
+            .merge_base_commit
+            .sha;
+
+        // Get the comparison between the oldbase..oldhead
+        let mut old = ctx
+            .github
+            .compare(&issue_repo, &oldbase, oldhead)
+            .await
+            .with_context(|| {
+                format!("failed to retrive the comparison between {oldbase} and {oldhead}")
+            })?;
+
+        // Sort by filename, so it's consistent with GitHub UI
+        old.files
+            .sort_unstable_by(|f1, f2| f1.filename.cmp(&f2.filename));
+
+        anyhow::Result::<_>::Ok((oldbase, old))
+    };
+
+    // Determine the newbase and get the comparison for the new diff
+    let new = async {
+        // Get the newbase from comparing master and newhead.
+        //
+        // See the comment above on old for more details.
+        let newbase = ctx
+            .github
+            .compare(&issue_repo, "master", newhead)
+            .await
+            .context("failed to retrive the comparison between master and newhead")?
+            .merge_base_commit
+            .sha;
+
+        // Get the comparison between the newbase..newhead
+        let mut new = ctx
+            .github
+            .compare(&issue_repo, &newbase, newhead)
+            .await
+            .with_context(|| {
+                format!("failed to retrive the comparison between {newbase} and {newhead}")
+            })?;
+
+        // Sort by filename, so it's consistent with GitHub UI
+        new.files
+            .sort_unstable_by(|f1, f2| f1.filename.cmp(&f2.filename));
+
+        anyhow::Result::<_>::Ok((newbase, new))
+    };
+
+    // Wait for both futures and early exit if there is an error
+    let ((oldbase, old), (newbase, new)) = futures::try_join!(old, new)?;
+
+    // Create the HTML buffer with a very rough approximation for the capacity
+    let mut html: String = String::with_capacity(800 + old.files.len() * 100);
+
+    // Write HTML header, style, ...
+    writeln!(
+        &mut html,
+        r#"<!DOCTYPE html>
+<html lang="en" translate="no">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link rel="icon" sizes="32x32" type="image/png" href="https://www.rust-lang.org/static/images/favicon-32x32.png">
+    <title>range-diff of {oldbase}...{oldhead} {newbase}...{newhead}</title>
+    <style>
+    body {{
+      font: 14px SFMono-Regular, Consolas, Liberation Mono, Menlo, monospace;
+    }}
+    @media (prefers-color-scheme: dark) {{
+      body {{
+        background: #0C0C0C;
+        color: #CCC;
+      }}
+      a {{
+        color: #41a6ff;
+      }}
+    }}
+    details {{
+      white-space: pre;
+    }}
+    summary {{
+      font-weight: 800;
+    }}
+    </style>
+</head>
+<body>
+<h3>range-diff of {oldbase}...{oldhead} {newbase}...{newhead}</h3>
+"#
+    )?;
+
+    let mut process_diffs = |filename, old_patch, new_patch| -> anyhow::Result<()> {
+        // Prepare input
+        let input: InternedInput<&str> = InternedInput::new(old_patch, new_patch);
+
+        // Compute the diff
+        let mut diff = Diff::compute(Algorithm::Histogram, &input);
+
+        // Run postprocessing to improve hunk boundaries
+        diff.postprocess_lines(&input);
+
+        // Determine if there are any differences
+        let has_hunks = diff.hunks().next().is_some();
+
+        if has_hunks {
+            let printer = HtmlDiffPrinter(&input.interner);
+            let diff = diff.unified_diff(&printer, config.clone(), &input);
+
+            writeln!(
+                html,
+                "<details open=\"\"><summary>{filename}</summary><pre>{diff}</pre></details>"
+            )?;
+        }
+        Ok(())
+    };
+
+    let mut seen_files = HashSet::<&str>::new();
+
+    // Process the old files
+    for old_file in &old.files {
+        let filename = &*old_file.filename;
+
+        let new_file_patch = new
+            .files
+            .iter()
+            .find(|f| f.filename == filename)
+            .map(|f| &*f.patch)
+            .unwrap_or_default();
+
+        seen_files.insert(filename);
+
+        process_diffs(filename, &*old_file.patch, new_file_patch)?;
+    }
+
+    // Process the not yet seen new files
+    for new_file in &new.files {
+        let filename = &*new_file.filename;
+
+        if seen_files.contains(filename) {
+            continue;
+        }
+
+        process_diffs(filename, "", &*new_file.patch)?;
+    }
+
+    writeln!(
+        html,
+        r#"
+</body>
+</html>
+        "#
+    )?;
+
+    let mut headers = HeaderMap::new();
+    headers.insert(
+        CONTENT_TYPE,
+        HeaderValue::from_static("text/html; charset=utf-8"),
+    );
+    headers.insert(
+        CACHE_CONTROL,
+        HeaderValue::from_static("public, max-age=15552000, immutable"),
+    );
+    headers.insert(
+        CONTENT_SECURITY_POLICY,
+        HeaderValue::from_static(
+            "default-src 'none'; style-src 'unsafe-inline'; img-src www.rust-lang.org",
+        ),
+    );
+
+    Ok((StatusCode::OK, headers, html))
+}
+
+struct HtmlDiffPrinter<'a>(pub &'a Interner<&'a str>);
+
+impl UnifiedDiffPrinter for HtmlDiffPrinter<'_> {
+    fn display_header(
+        &self,
+        _f: impl fmt::Write,
+        _start_before: u32,
+        _start_after: u32,
+        _len_before: u32,
+        _len_after: u32,
+    ) -> fmt::Result {
+        // ignore the header as does not represent anything meaningful for the range-diff
+        Ok(())
+    }
+
+    fn display_context_token(&self, mut f: impl fmt::Write, token: Token) -> fmt::Result {
+        let token = self.0[token];
+        write!(f, " ")?;
+        pulldown_cmark_escape::escape_html(FmtWriter(&mut f), token)?;
+        if !token.ends_with('\n') {
+            writeln!(f)?;
+        }
+        Ok(())
+    }
+
+    fn display_hunk(
+        &self,
+        mut f: impl fmt::Write,
+        before: &[Token],
+        after: &[Token],
+    ) -> fmt::Result {
+        if let Some(&last) = before.last() {
+            for &token in before {
+                let token = self.0[token];
+                write!(f, r#"<span style="color:red;">-"#)?;
+                pulldown_cmark_escape::escape_html(FmtWriter(&mut f), token)?;
+                write!(f, "</span>")?;
+            }
+            if !self.0[last].ends_with('\n') {
+                writeln!(f)?;
+            }
+        }
+
+        if let Some(&last) = after.last() {
+            for &token in after {
+                let token = self.0[token];
+                write!(f, r#"<span style="color:green;">+"#)?;
+                pulldown_cmark_escape::escape_html(FmtWriter(&mut f), token)?;
+                write!(f, "</span>")?;
+            }
+            if !self.0[last].ends_with('\n') {
+                writeln!(f)?;
+            }
+        }
+        Ok(())
+    }
+}