Merge pull request #1562 from chazkiker2/feature-note-command

feat: note command

.env.sample

@@ -0,0 +1,7 @@
+# if `GITHUB_API_TOKEN` is not set here, the token can also be stored in `~/.gitconfig`
+GITHUB_API_TOKEN=MUST_BE_CONFIGURED
+DATABASE_URL=MUST_BE_CONFIGURED
+GITHUB_WEBHOOK_SECRET=MUST_BE_CONFIGURED
+# for logging, refer to this document: https://rust-lang-nursery.github.io/rust-cookbook/development_tools/debugging/config_log.html
+# `RUSTC_LOG` is not required to run the application, but it makes local development easier
+# RUST_LOG=MUST_BE_CONFIGURED

.gitignore

@@ -1,2 +1,3 @@
 /target
-**/*.rs.bk
+**/*.rs.bk
+.env

Cargo.lock

@@ -860,6 +860,15 @@ version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68f2d64f2edebec4ce84ad108148e67e1064789bee435edc5b60ad398714a3a9"
 
+[[package]]
+name = "itertools"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "0.4.8"
@@ -1972,6 +1981,7 @@ dependencies = [
  "glob",
  "hex",
  "hyper",
+ "itertools",
  "lazy_static",
  "native-tls",
  "octocrab",

Cargo.toml

@@ -37,6 +37,7 @@ octocrab = "0.9.1"
 comrak = "0.8.2"
 route-recognizer = "0.3.0"
 cynic = { version = "0.14" }
+itertools = "0.10.2"
 
 [dependencies.serde]
 version = "1"

parser/src/command.rs

@@ -6,6 +6,7 @@ pub mod assign;
 pub mod close;
 pub mod glacier;
 pub mod nominate;
+pub mod note;
 pub mod ping;
 pub mod prioritize;
 pub mod relabel;
@@ -27,6 +28,7 @@ pub enum Command<'a> {
     Glacier(Result<glacier::GlacierCommand, Error<'a>>),
     Shortcut(Result<shortcut::ShortcutCommand, Error<'a>>),
     Close(Result<close::CloseCommand, Error<'a>>),
+    Note(Result<note::NoteCommand, Error<'a>>),
 }
 
 #[derive(Debug)]
@@ -96,6 +98,11 @@ impl<'a> Input<'a> {
             Command::Assign,
             &original_tokenizer,
         ));
+        success.extend(parse_single_command(
+            note::NoteCommand::parse,
+            Command::Note,
+            &original_tokenizer,
+        ));
         success.extend(parse_single_command(
             ping::PingCommand::parse,
             Command::Ping,
@@ -191,6 +198,7 @@ impl<'a> Command<'a> {
             Command::Glacier(r) => r.is_ok(),
             Command::Shortcut(r) => r.is_ok(),
             Command::Close(r) => r.is_ok(),
+            Command::Note(r) => r.is_ok(),
         }
     }
 

parser/src/command/note.rs

@@ -0,0 +1,55 @@
+use crate::error::Error;
+use crate::token::{Token, Tokenizer};
+use std::fmt;
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum NoteCommand {
+    Summary { title: String },
+    Remove { title: String },
+}
+
+#[derive(PartialEq, Eq, Debug)]
+pub enum ParseError {
+    MissingTitle,
+}
+impl std::error::Error for ParseError {}
+impl fmt::Display for ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ParseError::MissingTitle => write!(f, "missing required summary title"),
+        }
+    }
+}
+
+impl NoteCommand {
+    pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
+        let mut toks = input.clone();
+        if let Some(Token::Word("note")) = toks.peek_token()? {
+            toks.next_token()?;
+            let mut remove = false;
+            loop {
+                match toks.next_token()? {
+                    Some(Token::Word(title)) if title == "remove" => {
+                        remove = true;
+                        continue;
+                    }
+                    Some(Token::Word(title)) | Some(Token::Quote(title)) => {
+                        let command = if remove {
+                            NoteCommand::Remove {
+                                title: title.to_string(),
+                            }
+                        } else {
+                            NoteCommand::Summary {
+                                title: title.to_string(),
+                            }
+                        };
+                        break Ok(Some(command));
+                    }
+                    _ => break Err(toks.error(ParseError::MissingTitle)),
+                };
+            }
+        } else {
+            Ok(None)
+        }
+    }
+}

src/config.rs

@@ -31,6 +31,7 @@ pub(crate) struct Config {
     pub(crate) github_releases: Option<GitHubReleasesConfig>,
     pub(crate) review_submitted: Option<ReviewSubmittedConfig>,
     pub(crate) shortcut: Option<ShortcutConfig>,
+    pub(crate) note: Option<NoteConfig>,
 }
 
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
@@ -77,6 +78,12 @@ pub(crate) struct AssignConfig {
     _empty: (),
 }
 
+#[derive(PartialEq, Eq, Debug, serde::Deserialize)]
+pub(crate) struct NoteConfig {
+    #[serde(default)]
+    _empty: (),
+}
+
 #[derive(PartialEq, Eq, Debug, serde::Deserialize)]
 #[serde(rename_all = "kebab-case")]
 pub(crate) struct RelabelConfig {
@@ -252,6 +259,8 @@ mod tests {
 
             [assign]
 
+            [note]
+
             [ping.compiler]
             message = """\
             So many people!\
@@ -301,6 +310,7 @@ mod tests {
                     allow_unauthenticated: vec!["C-*".into()],
                 }),
                 assign: Some(AssignConfig { _empty: () }),
+                note: Some(NoteConfig { _empty: () }),
                 ping: Some(PingConfig { teams: ping_teams }),
                 nominate: Some(NominateConfig {
                     teams: nominate_teams

src/handlers.rs

@@ -31,6 +31,7 @@ mod glacier;
 mod major_change;
 mod milestone_prs;
 mod nominate;
+mod note;
 mod notification;
 mod notify_zulip;
 mod ping;
@@ -243,6 +244,7 @@ command_handlers! {
     major_change: Second,
     shortcut: Shortcut,
     close: Close,
+    note: Note,
 }
 
 pub struct Context {

src/handlers/assign.rs

@@ -52,7 +52,7 @@ pub(super) async fn handle_command(
                 return Ok(());
             }
         };
-        // Don't re-assign if aleady assigned, e.g. on comment edit
+        // Don't re-assign if already assigned, e.g. on comment edit
         if issue.contain_assignee(&username) {
             log::trace!(
                 "ignoring assign PR {} to {}, already assigned",

src/handlers/note.rs

@@ -0,0 +1,165 @@
+//! Allow users to add summary comments in Issues & Pull Requests.
+//!
+//! Users can make a new summary entry by commenting the following:
+//!
+//! ```md
+//! @rustbot note summary-title
+//! ```
+//!
+//! If this is the first summary entry, rustbot will amend the original post (the top-level comment) to add a "Notes" section. The section should **not** be edited by hand.
+//!
+//! ```md
+//! <!-- TRIAGEBOT_SUMMARY_START -->
+//!
+//! ### Summary Notes
+//!
+//! - ["summary-title" by @username](link-to-comment)
+//!
+//! Generated by triagebot, see [help](https://github.com/rust-lang/triagebot/wiki/Note) for how to add more
+//! <!-- TRIAGEBOT_SUMMARY_END -->
+//! ```
+//!
+//! If this is *not* the first summary entry, rustbot will simply append the new entry to the existing notes section:
+//!
+//! ```md
+//! <!-- TRIAGEBOT_SUMMARY_START -->
+//!
+//! ### Summary Notes
+//!
+//! - ["first-note" by @username](link-to-comment)
+//! - ["second-note" by @username](link-to-comment)
+//! - ["summary-title" by @username](link-to-comment)
+//!
+//! <!-- TRIAGEBOT_SUMMARY_END -->
+//! ```
+//!
+
+use crate::{config::NoteConfig, github::Event, handlers::Context, interactions::EditIssueBody};
+use itertools::Itertools;
+use parser::command::note::NoteCommand;
+use std::{cmp::Ordering, collections::HashMap};
+use tracing as log;
+
+#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize, Clone)]
+struct NoteDataEntry {
+    title: String,
+    comment_url: String,
+    author: String,
+}
+
+impl NoteDataEntry {
+    pub fn to_markdown(&self) -> String {
+        format!(
+            "\n- [\"{title}\" by @{author}]({comment_url})",
+            title = self.title,
+            author = self.author,
+            comment_url = self.comment_url
+        )
+    }
+}
+impl Ord for NoteDataEntry {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.comment_url.cmp(&other.comment_url)
+    }
+}
+impl PartialOrd for NoteDataEntry {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize, Default)]
+struct NoteData {
+    entries_by_url: HashMap<String, NoteDataEntry>,
+}
+
+impl NoteData {
+    pub fn get_url_from_title(&self, title: &str) -> Option<String> {
+        let tmp = self.entries_by_url.clone();
+        tmp.iter().sorted().find_map(|(key, val)| {
+            if val.title == title {
+                Some(key.to_owned())
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn remove_by_title(&mut self, title: &str) -> Option<NoteDataEntry> {
+        if let Some(url_to_remove) = self.get_url_from_title(title) {
+            if let Some(entry) = self.entries_by_url.remove(&url_to_remove) {
+                log::debug!("SUCCESSFULLY REMOVED ENTRY: {:#?}", &entry);
+                Some(entry)
+            } else {
+                log::debug!("UNABLE TO REMOVE ENTRY WITH URL: {:?}", &url_to_remove);
+                None
+            }
+        } else {
+            log::debug!("UNABLE TO REMOVE ENTRY WITH TITLE: {:?}", title);
+            None
+        }
+    }
+
+    pub fn to_markdown(&self) -> String {
+        if self.entries_by_url.is_empty() {
+            return String::new();
+        }
+
+        let mut text = String::from("\n### Summary Notes\n");
+        for (_, entry) in self.entries_by_url.iter().sorted() {
+            text.push_str(&entry.to_markdown());
+        }
+        text.push_str("\n\nGenerated by triagebot, see [help](https://github.com/rust-lang/triagebot/wiki/Note) for how to add more");
+        text
+    }
+}
+
+pub(super) async fn handle_command(
+    ctx: &Context,
+    _config: &NoteConfig,
+    event: &Event,
+    cmd: NoteCommand,
+) -> anyhow::Result<()> {
+    let issue = event.issue().unwrap();
+    let e = EditIssueBody::new(&issue, "SUMMARY");
+
+    let mut current: NoteData = e.current_data().unwrap_or_default();
+
+    let comment_url = String::from(event.html_url().unwrap());
+    let author = event.user().login.to_owned();
+
+    match &cmd {
+        NoteCommand::Summary { title } => {
+            let title = title.to_owned();
+            if let Some(existing_entry) = current.entries_by_url.get_mut(&comment_url) {
+                existing_entry.title = title;
+                log::debug!("Updated existing entry: {:#?}", existing_entry);
+            } else {
+                let new_entry = NoteDataEntry {
+                    title,
+                    comment_url: comment_url.clone(),
+                    author,
+                };
+                log::debug!("New Note Entry: {:#?}", new_entry);
+                current
+                    .entries_by_url
+                    .insert(comment_url, new_entry);
+                log::debug!("Entries by URL: {:#?}", current.entries_by_url);
+            }
+        }
+        NoteCommand::Remove { title } => {
+            if let Some(entry) = current.remove_by_title(title) {
+                log::debug!("SUCCESSFULLY REMOVED ENTRY: {:#?}", entry);
+            } else {
+                log::debug!("UNABLE TO REMOVE ENTRY");
+            }
+        }
+    }
+
+    let new_markdown = current.to_markdown();
+    log::debug!("New MD: {:#?}", new_markdown);
+
+    e.apply(&ctx.github, new_markdown, current).await?;
+
+    Ok(())
+}