Merge branch 'plugin_update_log'

Author: iovis

Cargo.lock

@@ -27,6 +27,7 @@ serde = { version = "1.0.228", features = ["derive"] }
 serde_path_to_error = "0.1.16"
 thiserror = "2.0.17"
 toml_edit = { version = "0.23.7", features = ["serde"] }
+timeago = "0.4"
 url = "2.5.7"
 
 [dev-dependencies]

Cargo.toml

@@ -16,6 +16,14 @@ pub fn format_plugin_errors(
     miette::miette!("Some plugins failed to {operation}\n{error_messages}")
 }
 
+const OSC8_PREFIX: &str = "\u{1b}]8;;";
+const OSC8_SUFFIX: &str = "\u{1b}]8;;\u{1b}\\";
+
+/// Wraps `message` in an OSC 8 hyperlink sequence pointing to `url`.
+pub fn hyperlink(message: &str, url: &str) -> String {
+    format!("{OSC8_PREFIX}{url}\u{1b}\\{message}{OSC8_SUFFIX}")
+}
+
 #[derive(Debug, Clone, Copy)]
 enum PluginSpinnerResult {
     AlreadyInstalled,
@@ -91,3 +99,25 @@ impl PluginSpinner {
         self.pb.finish_with_message(message);
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn hyperlink_wraps_message_with_osc8_sequence() {
+        let message = "hash";
+        let url = "https://example.com/commit";
+        let expected = format!("{OSC8_PREFIX}{url}\u{1b}\\{message}{OSC8_SUFFIX}");
+
+        assert_eq!(hyperlink(message, url), expected);
+    }
+
+    #[test]
+    fn hyperlink_allows_empty_message() {
+        let url = "https://example.com";
+        let expected = format!("{OSC8_PREFIX}{url}\u{1b}\\{OSC8_SUFFIX}");
+
+        assert_eq!(hyperlink("", url), expected);
+    }
+}

src/commands/plugins/ui.rs

@@ -1,12 +1,14 @@
 use std::sync::Mutex;
 use std::thread;
+use std::time::{Duration, SystemTime};
 
 use indicatif::MultiProgress;
 use miette::Result;
 use owo_colors::OwoColorize;
+use timeago::Formatter;
 
 use super::ui::{self, PluginSpinner};
-use crate::muxi::{PluginUpdateStatus, Settings};
+use crate::muxi::{PluginChange, PluginUpdateStatus, Settings};
 
 pub fn update() -> Result<()> {
     let plugins = Settings::from_lua()?.plugins;
@@ -18,19 +20,40 @@ pub fn update() -> Result<()> {
 
     let multi = MultiProgress::new();
     let errors = Mutex::new(Vec::new());
+    let change_logs = Mutex::new(Vec::new());
 
     thread::scope(|s| {
-        for plugin in plugins {
-            s.spawn(|| {
-                let spinner = PluginSpinner::new(&multi, &plugin.name);
+        for (index, plugin) in plugins.into_iter().enumerate() {
+            let progress = &multi;
+            let errors_ref = &errors;
+            let change_logs_ref = &change_logs;
+
+            s.spawn(move || {
+                let spinner = PluginSpinner::new(progress, &plugin.name);
+                let plugin_name = plugin.name.clone();
 
                 match plugin.update() {
-                    Ok(PluginUpdateStatus::Updated { from, to }) => {
-                        let detail = match from {
+                    Ok(PluginUpdateStatus::Updated {
+                        from,
+                        to,
+                        changes,
+                        range_url,
+                    }) => {
+                        let display = match from {
                             Some(from) => format!("{from}..{to}"),
                             None => to,
                         };
+                        let detail = if let Some(url) = range_url.as_ref() {
+                            ui::hyperlink(&display, url)
+                        } else {
+                            display
+                        };
                         spinner.finish_success(Some(&detail));
+
+                        if !changes.is_empty() {
+                            let log = format_plugin_changes(&plugin_name, &changes);
+                            change_logs_ref.lock().unwrap().push((index, log));
+                        }
                     }
                     Ok(PluginUpdateStatus::UpToDate { commit }) => {
                         spinner.finish_up_to_date(Some(&commit));
@@ -40,17 +63,62 @@ pub fn update() -> Result<()> {
                     }
                     Err(error) => {
                         spinner.finish_error();
-                        errors.lock().unwrap().push((plugin, error));
+                        errors_ref.lock().unwrap().push((plugin.clone(), error));
                     }
                 }
             });
         }
     });
 
+    drop(multi);
+
+    let mut change_logs = change_logs.into_inner().unwrap();
+    change_logs.sort_by_key(|(index, _)| *index);
+    if !change_logs.is_empty() {
+        println!();
+        for (_, log) in change_logs {
+            println!("{log}");
+        }
+    }
+
     let errors = errors.into_inner().unwrap();
     if errors.is_empty() {
         Ok(())
     } else {
         Err(ui::format_plugin_errors(&errors, "update"))
     }
 }
+
+fn format_plugin_changes(plugin_name: &str, changes: &[PluginChange]) -> String {
+    let header = plugin_name.bold().to_string();
+
+    let body = changes
+        .iter()
+        .map(|change| {
+            let id_colored = change.id.green().bold().to_string();
+            let id_formatted = change
+                .url
+                .as_ref()
+                .map_or_else(|| id_colored.clone(), |url| ui::hyperlink(&id_colored, url));
+
+            format!(
+                "  {} {} {}",
+                id_formatted,
+                change.summary.trim(),
+                format!("({})", format_relative_time(change.time)).dimmed()
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+
+    format!("{header}\n{body}")
+}
+
+fn format_relative_time(time: SystemTime) -> String {
+    let now = SystemTime::now();
+    let duration = now
+        .duration_since(time)
+        .unwrap_or_else(|_| Duration::from_secs(0));
+
+    Formatter::new().convert(duration)
+}